cs.jdoner.me Advancement Programming Exam

When do you take the APE?

Pick the horizon that matches you. Each plan states its time budget and what it cuts.

{{ sittingLine }}

The four parts

100 points. Hidden JUnit files named *Tests grade the exam; two rules are applied by a human reader.

{{ p.lastText }}

In 4 hours

The walk-in checklist

Time budget: the last four hours. Recall and trap avoidance only; nothing new is learned in four hours.

Cut on purpose: every drill, every typed ladder, everything at practice depth. Read, recite, stop.

Recite the zeros

Say each rule aloud, then mark it.

The exact call shapes

Scanner in, PrintStream out. Read each shape once.

{{ cs.t }}

                {{ ln }}

              

The strings the graders match

Character for character. The bordered \r\n is a CRLF pair.

                
                  {{ seg.text }}
                  \r\n

Doubles print at full raw precision through concatenation: 3.141592653589793, never 3.14. A double 1.0 prints as 1.0, never 1.

One read-through per part

The smallest task in each part, by points. Read; do not start new practice now.

▸ {{ fr.part }} {{ fr.name }} {{ fr.pts }} pts

                  {{ ln }}

                

Zero trap: {{ fr.trap }}

Walk-in facts

Tomorrow

One evening, ordered by points per minute

Time budget: one evening, three to four hours, one sitting. Four blocks, in order: the rules that zero whole parts, one typed pass over every task, the exact strings, then the two most-failed skills.

Cut on purpose: full drills, the edge-case ladders, and the timed dry run. Those need days; tonight has hours.

The rules that zero a part

10 min, read and recite

Any one of these five zeroes a problem or a whole part, no matter how good the code is. Read each card, say the rule, run its five-second check.

0 {{ z.t }}

The self-check loop

Every problem ships a *Main file, and the expected console output sits in a block comment at the bottom of that Main. Run the Main, diff your console against the comment line by line, and only then move on. The Main is the exam-day self-check; the hidden *Tests files produce the score.

One pass through all four parts

about 2 h, typed

Open the Spring 2023 practice APE; the department distributes it for studying. For every task below, type each rung yourself in the practice project. Do not paste. The point counts are the real grading weights.

Data Abstraction 30 pts · about 35 min

▸ {{ tk.name }} {{ tk.files }} {{ tk.pts }} pts

You write: {{ tk.writes }}

Zero trap: {{ tp }}

Skip tonight: rewriting setRadius or setHeight. You call the setters; you never write them.

General 30 pts · about 45 min

▸ {{ tk.name }} {{ tk.files }} {{ tk.pts }} pts

You write: {{ tk.writes }}

Zero trap: {{ tp }}

Skip tonight: memorizing the two catch-branch messages; no test reaches them. Know that the try/catch must exist or the file does not compile.

Linked List 20 pts · about 30 min

▸ {{ tk.name }} {{ tk.files }} {{ tk.pts }} pts

You write: {{ tk.writes }}

Zero trap: {{ tp }}

Skip tonight: node relinking. Every list answer here allocates fresh nodes, moves a chain, or swaps data; none rewires node by node.

Recursion 20 pts · about 20 min

▸ {{ tk.name }} {{ tk.files }} {{ tk.pts }} pts

You write: {{ tk.writes }}

Zero trap: {{ tp }}

Skip tonight: nothing in this part. Recursion is the most-failed part of the exam; both ladders get full passes.

The exact-string pass

30 min, typed from memory

The graders match output character for character: CRLF pairs, one-space colons, full double precision. Sibling messages differ by one word or one space. Type each string from memory, then reveal. Write \r\n where the string carries a CRLF pair.

                    
                      {{ seg.text }}
                      \r\n

The two most-failed skills

40 min, practice depth

Course records put Recursion first and file I/O second among failed parts. Tonight the deepest passes go to recursion base cases and the dummy-head splice.

Recursion base cases

Redo both ladders above and add the deliberate failures: in findLargest, say what happens when the recursive argument is i instead of i+1.
In reverseArray, change left < right to left != right in your head and trace {1,2}: swap, swap back, then an index leaves the array or the stack overflows.
Write both base cases on paper from memory, before any recursive call: if (i < array.length) and if (left < right).

no drill for this part yet · 20 pts

The ladders above are the practice.

The dummy-head splice

Draw clone on a two-item list: source walker on head.next, copy walker on the copy dummy, lockstep to the end.
Draw cutList at 0, at 1, and at size on a three-item list. Say which pointer is null in each drawing.
Say which task has the dummy (clone) and which do not (cutList, addAll), and where each walk starts because of it.

Pointer Workbench Linked List lesson

End the plan there. Before the projects open tomorrow, recite the five zero rules once.

This weekend

Two or three sittings

Time budget: two or three sittings of two to three hours each. Practice depth on every task family, full drills where they exist, edge-case ladders for the linked list variants, one timed dry run.

Nothing is cut from coverage at this horizon; the extra hours go to Recursion and Files, the two most-failed parts.

Sitting 1 Data Abstraction and General, at practice depth

Type every Data Abstraction and General ladder from the Tomorrow tab, including the deliberate-failure steps.
Run the drills that exist for these parts, full length.
Inheritance has no drill yet; it is 20 points. Use the Circle and Cylinder ladders.
The Selection Sort drill uses arrays; the exam sorts a dummy-head linked list by swapping data. Say the difference out loud when you finish it.

CompareTo File Reader Selection Sort Inheritance: no drill yet

Sitting 2 Linked List and Recursion, with the edge-case ladders

clone on 0, 1, and 10 items; check toString equality and head.next inequality each time.
cutList at -1, 0, 1, size, and size + 1; the clamp is what passes the first and the last.
addAll with null, an empty List, into an empty linked list, and into a five-item list.
Both recursion ladders, then both deliberate-failure traces, then both base cases from memory on paper.
Recursion has no drill yet; it is 20 points and the most-failed part. The ladders are the practice.

Linked List lesson Pointer Workbench Copy Constructor Recursion: no drill yet

Sitting 3 One timed dry run

All four parts of the Spring 2023 practice exam in one sitting, in exam order.
Self-check only through each *Main and its expected-output comment; no solved code until the end.
Finish with the five zero rules: compile everything, search the sort for API calls, search the recursion for loops, check the fences.

In a week

One part per day

Time budget: seven days, thirty to forty-five minutes each. Short daily sessions: one part family per day with its drills and ladders, recall decks near the end, the weakest part again on the last day.

Day {{ d.n }}

This quarter

One part family per week

Time budget: about a month, two or three short sessions per week. A paced pass through the full ladder set, one part family per week, with the drills as the checkpoint that closes each week.

Week {{ w.n }}

Close the month with the weekend plan above: its three sittings are the final pass, and its dry run is the readiness check.

Next quarter

The course-aligned path

Time budget: a full term, no urgency. Follow CSCD 211 as it runs. The lessons cover each part family as the course reaches it, and each drill is the capstone for its part. When a sitting is announced, pick the horizon above that matches it.

no drill yet

Open the CSCD 211 map

        Points, tasks, traps, and strings: Spring 2023 practice APE projects and the official instruction packets
        Passing the APE is required before CSCD 320, 350, and 371
      